{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "479b29bd-6b49-4bda-ab13-79fb6ee8b724",
   "metadata": {},
   "source": [
    "# 1. Bring in standard imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1df0982e-242d-4fff-bc56-7ede99115e0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bd843bd-4568-4954-ba81-c78a7eb8068c",
   "metadata": {},
   "source": [
    "# 2. Open up data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a21237a2-3613-4cd8-b52d-50b2ff20d14c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#specify location of precipitaiton data here\n",
    "path_prec = r'...'\n",
    "fpart,secpart = 'Ts', '_hourly3d.nc'\n",
    "surf_temps = (280, 290, 300, 310)\n",
    "\n",
    "fpaths = [os.path.join(path_prec, fpart + str(Ts) + secpart) for Ts in surf_temps]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "84300618-e03b-4ccf-84ed-d11a93b2c29d",
   "metadata": {},
   "outputs": [],
   "source": [
    "prec_dic = { str(Ts) + 'K' : xr.open_dataset(fpath,decode_times = False)['prec_mp'] \n",
    "            for (Ts, fpath) in zip(surf_temps, fpaths)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f295524-91a6-4e3e-8e5f-085f6593b44f",
   "metadata": {},
   "source": [
    "# 3. Function to make plots"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "822f4e33-d7d1-4692-a614-1cfd2f9fcffa",
   "metadata": {},
   "source": [
    "## 3.1 Function that used to make old Figure 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "64533700-8095-485b-a69b-94928a6c2b35",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any, Dict, List, Literal, Optional, Tuple\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "from pathlib import Path\n",
    "import copy\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize, LinearSegmentedColormap\n",
    "from matplotlib.gridspec import GridSpec\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "\n",
    "def _white_blue_darkblue() -> LinearSegmentedColormap:\n",
    "    \"\"\"Custom colormap from white → blue → dark blue.\"\"\"\n",
    "    colors = [\"#FFFFFF\", \"#3B82F6\", \"#1E3A8A\"]\n",
    "    return LinearSegmentedColormap.from_list(\"white_blue_darkblue\", colors, N=256)\n",
    "\n",
    "\n",
    "def make_precip_figure(\n",
    "    precip_by_Ts: Dict[str, xr.DataArray],\n",
    "    Ts_order: List[str],\n",
    "    time_mode: Literal[\"index\", \"random\"],\n",
    "    time_index: Optional[int] = None,\n",
    "    rng_seed: int = 42,\n",
    "    show_bottom_row: bool = True,\n",
    "    save: bool = False,\n",
    "    out_dir: str = \"./figures\",\n",
    "    filename: str = \"precip_Ts_2xN.pdf\",\n",
    "    title: Optional[str] = None,\n",
    ") -> Dict[str, Any]:\n",
    "    \"\"\"\n",
    "    Create a precipitation map figure over several surface temperatures Ts.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    precip_by_Ts : mapping of Ts_key → xarray DataArray\n",
    "        Each DataArray must have dimensions (\"time\", \"grid_yt\", \"grid_xt\").\n",
    "    Ts_order : list of str\n",
    "        Ordering of keys in precip_by_Ts to plot (e.g. [\"280K\",\"290K\",...]).\n",
    "    time_mode : {\"index\", \"random\"}\n",
    "        If \"index\", use the given time_index; if \"random\", pick randomly per Ts.\n",
    "    time_index : optional int\n",
    "        Time index to use if time_mode == \"index\".\n",
    "    rng_seed : int\n",
    "        Seed for random number generator (when time_mode == \"random\").\n",
    "    show_bottom_row : bool\n",
    "        Whether to include the bottom row (with common normalization) or not.\n",
    "    save : bool\n",
    "        Whether to save the figure.\n",
    "    out_dir : str\n",
    "        Directory to save into (if save=True).\n",
    "    filename : str\n",
    "        Filename (within out_dir) to save figure.\n",
    "    title : optional str\n",
    "        A suptitle for the figure.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    artifacts : dict\n",
    "        Contains handles and metadata:\n",
    "        - \"fig\": the matplotlib Figure\n",
    "        - \"axes_top\": list of top-row Axes\n",
    "        - \"chosen_idx\": dict mapping Ts_key → time index used\n",
    "        - \"vmax_top\": dict mapping Ts_key → vmax used in top row\n",
    "        If show_bottom_row is True, also includes:\n",
    "        - \"axes_bottom\": list of bottom-row Axes\n",
    "        - \"ax_cbar_bottom\": the bottom-row colorbar Axes\n",
    "        - \"bottom_limits\": (vmin_btm, vmax_btm)\n",
    "\n",
    "    \"\"\"\n",
    "    # Validate inputs\n",
    "    if not Ts_order:\n",
    "        raise ValueError(\"Ts_order must be non-empty.\")\n",
    "    missing = [k for k in Ts_order if k not in precip_by_Ts]\n",
    "    if missing:\n",
    "        raise KeyError(f\"Missing Ts keys: {missing}\")\n",
    "    # Extract grid coordinates & ensure consistency\n",
    "    grids: Optional[Tuple[np.ndarray, np.ndarray]] = None\n",
    "    for k in Ts_order:\n",
    "        da = precip_by_Ts[k]\n",
    "        if not isinstance(da, xr.DataArray):\n",
    "            raise TypeError(f\"precip_by_Ts[{k}] must be an xarray.DataArray.\")\n",
    "        required = {\"time\", \"grid_yt\", \"grid_xt\"}\n",
    "        if not required.issubset(set(da.dims)):\n",
    "            raise ValueError(f\"DataArray for '{k}' dims {da.dims}, but require {required}\")\n",
    "        # Get x,y coords\n",
    "        x = da.coords[\"grid_xt\"].values\n",
    "        y = da.coords[\"grid_yt\"].values\n",
    "        if grids is None:\n",
    "            grids = (x.copy(), y.copy())\n",
    "        else:\n",
    "            x0, y0 = grids\n",
    "            if x.shape != x0.shape or y.shape != y0.shape or not (np.allclose(x, x0) and np.allclose(y, y0)):\n",
    "                raise ValueError(\"All Ts must share identical grid_xt / grid_yt.\")\n",
    "    assert grids is not None\n",
    "    x, y = grids\n",
    "    extent = [float(x.min()), float(x.max()), float(y.min()), float(y.max())]\n",
    "\n",
    "    # Time index selection\n",
    "    if time_mode == \"index\":\n",
    "        if time_index is None:\n",
    "            raise ValueError(\"Must supply time_index when time_mode == 'index'.\")\n",
    "    elif time_mode == \"random\":\n",
    "        rng = np.random.default_rng(rng_seed)\n",
    "    else:\n",
    "        raise ValueError(\"time_mode must be 'index' or 'random'.\")\n",
    "\n",
    "    chosen_idx: Dict[str, int] = {}\n",
    "    for k in Ts_order:\n",
    "        tlen = precip_by_Ts[k].sizes[\"time\"]\n",
    "        if time_mode == \"random\":\n",
    "            idx = int(rng.integers(0, tlen))\n",
    "        else:\n",
    "            # wrap-around allowed\n",
    "            idx = int(time_index % tlen)\n",
    "        chosen_idx[k] = idx\n",
    "\n",
    "    # Extract 2D fields at chosen times\n",
    "    field2d: Dict[str, xr.DataArray] = {}\n",
    "    for k in Ts_order:\n",
    "        da = precip_by_Ts[k].isel(time=chosen_idx[k])\n",
    "        if da.dims != (\"grid_yt\", \"grid_xt\"):\n",
    "            da = da.transpose(\"grid_yt\", \"grid_xt\")\n",
    "        field2d[k] = da.astype(float)\n",
    "\n",
    "    # Define top-row maxima based on Ts\n",
    "    BASE, ALPHA, TREF = 250.0, 0.07, 280.0\n",
    "    def _parse_Ts(ts_key: str) -> float:\n",
    "        try:\n",
    "            return float(ts_key.rstrip(\"K\"))\n",
    "        except:\n",
    "            raise ValueError(f\"Ts key '{ts_key}' must end with 'K'.\")\n",
    "    vmax_top: Dict[str, float] = {}\n",
    "    for k in Ts_order:\n",
    "        T = _parse_Ts(k)\n",
    "        vmax_top[k] = float(BASE * np.exp(ALPHA * (T - TREF)))\n",
    "\n",
    "    # Bottom row normalization constants (will be used only if show_bottom_row)\n",
    "    # We’ll base bottom row vmax on Ts = “290K” if present\n",
    "    vmin_btm, vmax_btm = 0.0, vmax_top.get(\"290K\", None)  # fallback if missing\n",
    "\n",
    "    # Set up figure & GridSpec\n",
    "    N = len(Ts_order)\n",
    "    num_rows = 2 if show_bottom_row else 1\n",
    "    fig = plt.figure(figsize=(7.0, 4.8))\n",
    "    cbar_col_width = 0.06\n",
    "    width_ratios = [cbar_col_width] + [1.0] * N\n",
    "    height_ratios = [1.0] * num_rows\n",
    "    gs = GridSpec(num_rows, N + 1, figure=fig,\n",
    "                  width_ratios=width_ratios,\n",
    "                  height_ratios=height_ratios)\n",
    "\n",
    "    # Base colormap\n",
    "    base_cmap = _white_blue_darkblue()\n",
    "    cmap_bottom = copy.copy(base_cmap)\n",
    "    cmap_bottom.set_over(\"purple\")\n",
    "\n",
    "    # Normalize for bottom row (if used) - initialize, may be overwritten\n",
    "    norm_bottom = None\n",
    "    if show_bottom_row and vmax_btm is not None:\n",
    "        norm_bottom = Normalize(vmin=vmin_btm, vmax=vmax_btm, clip=False)\n",
    "\n",
    "    axes_top: List[plt.Axes] = []\n",
    "    cbar_axes_top: List[plt.Axes] = []\n",
    "\n",
    "    # --- Top row plotting ---\n",
    "    for j, k in enumerate(Ts_order):\n",
    "        ax = fig.add_subplot(gs[0, j + 1])\n",
    "        im = ax.imshow(\n",
    "            field2d[k].values,\n",
    "            origin=\"lower\",\n",
    "            extent=extent,\n",
    "            vmin=0.0,\n",
    "            vmax=vmax_top[k],\n",
    "            cmap=base_cmap,\n",
    "            interpolation=\"nearest\",\n",
    "            aspect=\"equal\",\n",
    "        )\n",
    "        ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)\n",
    "        # Title in LaTeX style\n",
    "        T_latex = f\"$T_{{s}} = {int(_parse_Ts(k))}\\\\,\\\\mathrm{{K}}$\"\n",
    "        ax.set_title(T_latex, fontsize=9)\n",
    "\n",
    "        # Colorbar for this top plot (horizontal under it)\n",
    "        divider = make_axes_locatable(ax)\n",
    "        cax = divider.append_axes(\"bottom\", size=\"6%\", pad=0.12)\n",
    "        cbar = fig.colorbar(im, cax=cax, orientation=\"horizontal\")\n",
    "        cbar.ax.locator_params(nbins=6)\n",
    "        cbar.set_label(\"\")  # no label here\n",
    "        cbar.ax.tick_params(labelsize=7)\n",
    "\n",
    "        axes_top.append(ax)\n",
    "        cbar_axes_top.append(cax)\n",
    "\n",
    "    # Add shared “mm/day” label under the row of top-row colorbars\n",
    "    fig.canvas.draw()\n",
    "    if cbar_axes_top:\n",
    "        bboxes = [cax.get_position(fig) for cax in cbar_axes_top]\n",
    "        xmin = min(bb.x0 for bb in bboxes)\n",
    "        xmax = max(bb.x1 for bb in bboxes)\n",
    "        y0 = min(bb.y0 for bb in bboxes)\n",
    "        # If we have only one row, raise the label slightly\n",
    "        vertical_offset = 0.015 if show_bottom_row else -0.17\n",
    "        fig.text((xmin + xmax) / 2, y0 - vertical_offset, \"mm/day\",\n",
    "                 ha=\"center\", va=\"top\", fontsize=9)\n",
    "\n",
    "    axes_bottom: List[plt.Axes] = []\n",
    "    ax_cbar_bottom = None\n",
    "\n",
    "    # --- Bottom row, conditional ---\n",
    "    if show_bottom_row:\n",
    "        # Plot bottom row of identical images (for comparison under same norm)\n",
    "        for j, k in enumerate(Ts_order):\n",
    "            ax = fig.add_subplot(gs[1, j + 1])\n",
    "            im = ax.imshow(\n",
    "                field2d[k].values,\n",
    "                origin=\"lower\",\n",
    "                extent=extent,\n",
    "                cmap=cmap_bottom,\n",
    "                norm=norm_bottom,\n",
    "                interpolation=\"nearest\",\n",
    "                aspect=\"equal\",\n",
    "            )\n",
    "            ax.tick_params(bottom=False, left=False,\n",
    "                           labelbottom=False, labelleft=False)\n",
    "            axes_bottom.append(ax)\n",
    "\n",
    "        # Shared colorbar for bottom row, spanning full width beneath bottom row\n",
    "        fig.canvas.draw()\n",
    "        pos = [ax.get_position(fig) for ax in axes_bottom]\n",
    "        xmin = min(p.x0 for p in pos)\n",
    "        xmax = max(p.x1 for p in pos)\n",
    "        ymin = min(p.y0 for p in pos)\n",
    "\n",
    "        cbar_width = xmax - xmin\n",
    "        cbar_height = 0.015\n",
    "        cbar_left = xmin\n",
    "        cbar_bottom = ymin - 0.035\n",
    "\n",
    "        cax_b = fig.add_axes([cbar_left, cbar_bottom, cbar_width, cbar_height])\n",
    "        sm = plt.cm.ScalarMappable(norm=norm_bottom, cmap=cmap_bottom)\n",
    "        cbar = fig.colorbar(sm, cax=cax_b, orientation=\"horizontal\", extend=\"max\")\n",
    "        cbar.set_label(\"mm/day\", fontsize=9)\n",
    "        ax_cbar_bottom = cax_b\n",
    "\n",
    "    # Adjust suptitle and spacing\n",
    "    if title:\n",
    "        # If only one row, place title slightly lower\n",
    "        ytitle = 0.98 if show_bottom_row else 0.96\n",
    "        fig.suptitle(title, fontsize=11, y=ytitle)\n",
    "\n",
    "    # Final layout adjustments\n",
    "    if show_bottom_row:\n",
    "        fig.subplots_adjust(left=0.06, right=0.995, top=0.98, bottom=0.08,\n",
    "                            wspace=0.12, hspace=0.03)\n",
    "    else:\n",
    "        # More vertical room, less bottom margin needed\n",
    "        fig.subplots_adjust(left=0.06, right=0.995, top=0.95, bottom=0.1,\n",
    "                            wspace=0.12, hspace=0.0)\n",
    "\n",
    "    # Build return dict\n",
    "    artifacts: Dict[str, Any] = {\n",
    "        \"fig\": fig,\n",
    "        \"axes_top\": axes_top,\n",
    "        \"chosen_idx\": chosen_idx,\n",
    "        \"vmax_top\": vmax_top,\n",
    "    }\n",
    "    if show_bottom_row:\n",
    "        artifacts.update({\n",
    "            \"axes_bottom\": axes_bottom,\n",
    "            \"ax_cbar_bottom\": ax_cbar_bottom,\n",
    "            \"bottom_limits\": (vmin_btm, vmax_btm),\n",
    "        })\n",
    "\n",
    "    # Save if requested\n",
    "    if save:\n",
    "        out_path = Path(out_dir)\n",
    "        out_path.mkdir(parents=True, exist_ok=True)\n",
    "        fig.savefig(out_path / filename, bbox_inches=\"tight\")\n",
    "\n",
    "    return artifacts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8d82950-5b58-4a19-9838-7d0058e27b4f",
   "metadata": {},
   "source": [
    "### 3.1.1 Refactored function for top row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a912ee9f-a246-43c8-9c1c-d1ecf474a4f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_precip_row(\n",
    "    fig,\n",
    "    gridspec_position,\n",
    "    precip_by_Ts: Dict[str, xr.DataArray],\n",
    "    Ts_order: List[str],\n",
    "    time_mode: Literal[\"index\", \"random\"],\n",
    "    time_index: Optional[int] = None,\n",
    "    rng_seed: int = 42,\n",
    ") -> List[plt.Axes]:\n",
    "    \"\"\"\n",
    "    Creates the 1x4 precipitation row in the given figure position.\n",
    "    For use in composite figures.\n",
    "    \"\"\"\n",
    "    # Validate inputs\n",
    "    if not Ts_order:\n",
    "        raise ValueError(\"Ts_order must be non-empty.\")\n",
    "    missing = [k for k in Ts_order if k not in precip_by_Ts]\n",
    "    if missing:\n",
    "        raise KeyError(f\"Missing Ts keys: {missing}\")\n",
    "    \n",
    "    # Extract grid coordinates & ensure consistency (same as before)\n",
    "    grids: Optional[Tuple[np.ndarray, np.ndarray]] = None\n",
    "    for k in Ts_order:\n",
    "        da = precip_by_Ts[k]\n",
    "        if not isinstance(da, xr.DataArray):\n",
    "            raise TypeError(f\"precip_by_Ts[{k}] must be an xarray.DataArray.\")\n",
    "        required = {\"time\", \"grid_yt\", \"grid_xt\"}\n",
    "        if not required.issubset(set(da.dims)):\n",
    "            raise ValueError(f\"DataArray for '{k}' dims {da.dims}, but require {required}\")\n",
    "        x = da.coords[\"grid_xt\"].values\n",
    "        y = da.coords[\"grid_yt\"].values\n",
    "        if grids is None:\n",
    "            grids = (x.copy(), y.copy())\n",
    "        else:\n",
    "            x0, y0 = grids\n",
    "            if x.shape != x0.shape or y.shape != y0.shape or not (np.allclose(x, x0) and np.allclose(y, y0)):\n",
    "                raise ValueError(\"All Ts must share identical grid_xt / grid_yt.\")\n",
    "    assert grids is not None\n",
    "    x, y = grids\n",
    "    extent = [float(x.min()), float(x.max()), float(y.min()), float(y.max())]\n",
    "\n",
    "    # Time index selection (same as before)\n",
    "    if time_mode == \"index\":\n",
    "        if time_index is None:\n",
    "            raise ValueError(\"Must supply time_index when time_mode == 'index'.\")\n",
    "    elif time_mode == \"random\":\n",
    "        rng = np.random.default_rng(rng_seed)\n",
    "    else:\n",
    "        raise ValueError(\"time_mode must be 'index' or 'random'.\")\n",
    "\n",
    "    chosen_idx: Dict[str, int] = {}\n",
    "    for k in Ts_order:\n",
    "        tlen = precip_by_Ts[k].sizes[\"time\"]\n",
    "        if time_mode == \"random\":\n",
    "            idx = int(rng.integers(0, tlen))\n",
    "        else:\n",
    "            idx = int(time_index % tlen)\n",
    "        chosen_idx[k] = idx\n",
    "\n",
    "    # Extract 2D fields at chosen times (same as before)\n",
    "    field2d: Dict[str, xr.DataArray] = {}\n",
    "    for k in Ts_order:\n",
    "        da = precip_by_Ts[k].isel(time=chosen_idx[k])\n",
    "        if da.dims != (\"grid_yt\", \"grid_xt\"):\n",
    "            da = da.transpose(\"grid_yt\", \"grid_xt\")\n",
    "        field2d[k] = da.astype(float)\n",
    "\n",
    "    # Define top-row maxima based on Ts (same as before)\n",
    "    BASE, ALPHA, TREF = 250.0, 0.07, 280.0\n",
    "    def _parse_Ts(ts_key: str) -> float:\n",
    "        try:\n",
    "            return float(ts_key.rstrip(\"K\"))\n",
    "        except:\n",
    "            raise ValueError(f\"Ts key '{ts_key}' must end with 'K'.\")\n",
    "    vmax_top: Dict[str, float] = {}\n",
    "    for k in Ts_order:\n",
    "        T = _parse_Ts(k)\n",
    "        vmax_top[k] = float(BASE * np.exp(ALPHA * (T - TREF)))\n",
    "\n",
    "    # Base colormap\n",
    "    base_cmap = _white_blue_darkblue()\n",
    "\n",
    "    # Create subgridspec within the provided position\n",
    "    N = len(Ts_order)\n",
    "    sub_gs = gridspec_position.subgridspec(1, N + 1, width_ratios=[0.06] + [1.0] * N)\n",
    "\n",
    "    axes_top: List[plt.Axes] = []\n",
    "    cbar_axes_top: List[plt.Axes] = []\n",
    "\n",
    "    # --- Top row plotting ---\n",
    "    for j, k in enumerate(Ts_order):\n",
    "        ax = fig.add_subplot(sub_gs[j + 1])  # Skip first column (for spacing)\n",
    "        im = ax.imshow(\n",
    "            field2d[k].values,\n",
    "            origin=\"lower\",\n",
    "            extent=extent,\n",
    "            vmin=0.0,\n",
    "            vmax=vmax_top[k],\n",
    "            cmap=base_cmap,\n",
    "            interpolation=\"nearest\",\n",
    "            aspect=\"equal\",\n",
    "        )\n",
    "        ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)\n",
    "        T_latex = f\"$T_{{s}} = {int(_parse_Ts(k))}\\\\,\\\\mathrm{{K}}$\"\n",
    "        ax.set_title(T_latex, fontsize=9)\n",
    "\n",
    "        # Colorbar for this top plot\n",
    "        divider = make_axes_locatable(ax)\n",
    "        cax = divider.append_axes(\"bottom\", size=\"6%\", pad=0.12)\n",
    "        cbar = fig.colorbar(im, cax=cax, orientation=\"horizontal\")\n",
    "        cbar.ax.locator_params(nbins=6)\n",
    "        cbar.set_label(\"\")\n",
    "        cbar.ax.tick_params(labelsize=7)\n",
    "\n",
    "        axes_top.append(ax)\n",
    "        cbar_axes_top.append(cax)\n",
    "\n",
    "    # Add shared \"mm/day\" label\n",
    "    fig.canvas.draw()\n",
    "    if cbar_axes_top:\n",
    "        bboxes = [cax.get_position(fig) for cax in cbar_axes_top]\n",
    "        xmin = min(bb.x0 for bb in bboxes)\n",
    "        xmax = max(bb.x1 for bb in bboxes)\n",
    "        y0 = min(bb.y0 for bb in bboxes)\n",
    "\n",
    "    return axes_top"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6237fc78-9fc3-4efe-901b-afeaef8e56ab",
   "metadata": {},
   "source": [
    "## 3.2 Code to make what used to be Figure 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b3db93-4ac9-4b7c-978d-7c1fac1b98b2",
   "metadata": {},
   "source": [
    "### 3.2.1 Load required stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a56de313-03d8-469c-93f4-ce98cf7a808d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#keep cell in case you want to see the log-structure plots\n",
    "from freq_amount_funcs import calculate_log_ratios\n",
    "from freq_amount_funcs import calc_Fd_and_histNormCounts as calc_dists\n",
    "from freq_amount_funcs import process_surface_temperature_cases as pstc \n",
    "from freq_amount_funcs import geo_series, midpoint_giver\n",
    "\n",
    "\n",
    "boundaries = geo_series(1.15,0.001,2000) #boundaries of the distributions at 7%, moe means \"midpoint of edges\"\n",
    "\n",
    "moe = midpoint_giver(boundaries)\n",
    "delLogR = calculate_log_ratios(boundaries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "790f7dbd-4071-45cb-a647-bb3f8cdac116",
   "metadata": {},
   "outputs": [],
   "source": [
    "#precip dictionary\n",
    "\n",
    "prec_array_dic = {k : prec_dic[k].values for k in prec_dic}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "705ab3b6-01ad-4033-b906-1b8607cf09af",
   "metadata": {},
   "outputs": [],
   "source": [
    "#get amount and freq arrays\n",
    "from freq_amount_funcs import (process_surface_temperature_cases as pstc, plot_distribution_panels,calc_Fd_and_histNormCounts as calc_Fd_n_Hist)\n",
    "\n",
    "s_labels = [2, 10, 100, 1000, 3000]\n",
    "sfig = os.path.join('/Volumes', 'COO', 'MFP_NJ', 'RESULTS', 'FIGS', 'AMOUNT_NORM')\n",
    "\n",
    "\n",
    "f_dists,a_dists = pstc(sfig, list(prec_array_dic.values()), list(prec_array_dic.keys()), boundaries, boundaries[0],delLogR, moe, \n",
    "                       calc_Fd_n_Hist, 'check_full_20',model_name='FV3')\n",
    "\n",
    "dist_dic = {k:(f_dist,arreglo) for k, f_dist,arreglo in zip(prec_array_dic.keys(),f_dists,a_dists)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8de6e6e5-c21f-4e15-8ea9-61aed2758e4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_distribution_row(fig, position):\n",
    "    \"\"\"\n",
    "    Creates the 1x2 distribution row in the given figure position.\n",
    "    Assumes all data and styling variables are available globally.\n",
    "    \"\"\"\n",
    "    # Create axes at the specified position\n",
    "    ax0 = fig.add_subplot(position[0])\n",
    "    ax1 = fig.add_subplot(position[1])\n",
    "    \n",
    "    # === Define temps ===\n",
    "    temp0 = surf_temps[0]\n",
    "    temp1 = surf_temps[1]\n",
    "    temp2 = surf_temps[2]\n",
    "    temp3 = surf_temps[3]\n",
    "\n",
    "    selected_labels = [0.1, 1, 10, 100, 1000, 2000]\n",
    "    # --- Color-blind friendly reddish-orange (CUD palette) ---\n",
    "    highlight_color = '#D55E00'\n",
    "    # --- Precompute y-limits ---\n",
    "    def visible_range(data):\n",
    "        mask = (boundaries[:-1] >= min(selected_labels)) & (boundaries[:-1] <= max(selected_labels))\n",
    "        return data[mask]\n",
    "    \n",
    "    max_freq_y = max(np.max(visible_range(dist_dic[str(temp1) +'K'][0])) for temp in surf_temps[:4]) * 1.1\n",
    "    max_amt_y = max(np.max(visible_range(dist_dic[str(temp2) +'K'][1])) for temp in surf_temps[:4]) * 1.1\n",
    "\n",
    "    # ========== PANEL A: Frequency ==========\n",
    "    s_labels = [0.1, 1, 10, 100, 200, 1000, 2000]\n",
    "\n",
    "    line_freq0 = ax0.stairs(dist_dic[str(temp1) +'K'][0], boundaries, linewidth=1, edgecolor=temp_color_map[temp1])\n",
    "    line_freq3 = ax0.stairs(dist_dic[str(temp2) +'K'][0], boundaries, linewidth=1, edgecolor=temp_color_map[temp2])\n",
    "\n",
    "    ax0.set_xscale('log')\n",
    "    ax0.xaxis.set_minor_locator(ticker.LogLocator(base=10.0, subs='auto', numticks=10))\n",
    "    ax0.set_xticks(s_labels)\n",
    "    ax0.set_xticklabels(s_labels, rotation=40)\n",
    "    ax0.set_xlim(min(s_labels), max(s_labels))\n",
    "    ax0.set_ylim(0, max_freq_y)\n",
    "    ax0.set_ylabel(r\"Prob. / $\\Delta \\log(\\mathrm{rr})$\", fontsize=9)\n",
    "    ax0.tick_params(labelsize = 7.5)\n",
    "    ax0.tick_params(labelleft=True)\n",
    "    ax0.text(0.02, 0.05, \"A\", transform=ax0.transAxes, fontsize=9, ha=\"left\", va=\"bottom\", color='gray')\n",
    "\n",
    "    ax0.legend(\n",
    "        handles=[line_freq0, line_freq3],\n",
    "        labels=[\"290 K\", \"300 K\"],\n",
    "        loc='upper right',\n",
    "        bbox_to_anchor=(0.9, 1.),\n",
    "        frameon=False,\n",
    "        fontsize=8\n",
    "    )\n",
    "\n",
    "    # ========== PANEL B: Amount ==========\n",
    "    line_amt1 = ax1.stairs(dist_dic[str(temp1) + 'K'][1], boundaries, linewidth=1, edgecolor=temp_color_map[temp1])\n",
    "    line_amt3 = ax1.stairs(dist_dic[str(temp2) + 'K'][1], boundaries, linewidth=1, edgecolor=temp_color_map[temp2])\n",
    "\n",
    "    amtB = 100  # mm/day\n",
    "    deltaT = 300 - 290\n",
    "    alpha = 0.07\n",
    "    amtT = amtB * np.exp(alpha * deltaT)\n",
    "\n",
    "    ax1.vlines(x=amtB, ymin=0, ymax=1, color=temp_color_map[temp1], linestyle='--', linewidth=1)\n",
    "    ax1.vlines(x=amtT, ymin=0, ymax=1.15, color=temp_color_map[temp2], linestyle='--', linewidth=1)\n",
    "\n",
    "    ax1.set_xscale('log')\n",
    "    ax1.xaxis.set_minor_locator(ticker.LogLocator(base=10.0, subs='auto', numticks=10))\n",
    "    ax1.set_xticks(s_labels)\n",
    "    ax1.set_xticklabels(s_labels, rotation=40)\n",
    "    ax1.set_xlim(min(s_labels), max(selected_labels))\n",
    "    ax1.set_ylim(0, 1.25)\n",
    "\n",
    "    ax1.yaxis.set_label_position(\"right\")\n",
    "    ax1.yaxis.tick_right()\n",
    "    ax1.tick_params(labelsize = 7.5)\n",
    "    ax1.set_ylabel(r\"Prob. / $\\Delta \\log(\\mathrm{rr}) \\cdot \\mathrm{rr}$\", fontsize = 9)\n",
    "\n",
    "    ax1.text(0.02, 0.05, \"B\", transform=ax1.transAxes, fontsize=9, ha=\"left\", va=\"bottom\", color='gray')\n",
    "\n",
    "    arrow_heights = [0.25, 0.60, 0.95]\n",
    "    for arrow_y in arrow_heights:\n",
    "        ax1.annotate(\n",
    "            '',\n",
    "            xy=(amtT, arrow_y), xycoords='data',\n",
    "            xytext=(amtB, arrow_y), textcoords='data',\n",
    "            arrowprops=dict(\n",
    "                arrowstyle=\"->\",\n",
    "                color=highlight_color,\n",
    "                linewidth=0.9,\n",
    "                shrinkA=0, shrinkB=0\n",
    "            )\n",
    "        )\n",
    "\n",
    "    texto = \"Peak rain rate going from 290 K to 300 K doubles, following CC scaling.\"\n",
    "    #texto = \"290 K peak location doubles with 10 K warming, following CC.\"\n",
    "    wrapped_text = textwrap.fill(texto, width=20)\n",
    "    ax1.text(0.01, 0.95, wrapped_text, \n",
    "             transform=ax1.transAxes, fontsize=7, ha=\"left\", va=\"top\", color=highlight_color)\n",
    "\n",
    "    return [ax0, ax1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dc37087-badb-4332-b914-1fee746e4f18",
   "metadata": {},
   "source": [
    "# 4. Make plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5c72f59-c18c-493d-9623-f329ae8040a8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "artifacts = make_precip_figure(\n",
    "    precip_by_Ts=prec_dic,\n",
    "    Ts_order=[\"280K\", \"290K\", \"300K\", \"310K\"],\n",
    "    show_bottom_row=False,\n",
    "    time_mode=\"index\",   # or \"index\"\n",
    "    time_index=23,       # set an integer when time_mode==\"index\"\n",
    "    rng_seed=69,\n",
    "    save=False,\n",
    "    out_dir=sloc,\n",
    "    filename=figname,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3a82482e-0265-4582-a7a4-1efdeddbcf84",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "# Color mapping\n",
    "cmap = matplotlib.colormaps['viridis']\n",
    "Ts = [280, 290, 300, 310]\n",
    "norm = mcolors.Normalize(vmin=min(Ts), vmax=max(Ts))\n",
    "temp_color_map = {T: cmap(norm(T)) for T in Ts}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a62693c2-9053-41d4-9afd-0e23d45180ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "import textwrap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "846923cc-c7c4-42b1-b439-f528bbb553a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#specify save directory here\n",
    "sloc = r'...'\n",
    "figname = 'FIGURE1.pdf'\n",
    "sdir = os.path.join(sloc,figname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7fc48023-900b-41fe-9568-20a11eccdd5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure saved to: /Volumes/COO/MFP_NJ/RESULTS/FIGS/FOR_PAPER/FIGURE1.pdf\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x420 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_combined_figure(save_path=None):\n",
    "    \"\"\"\n",
    "    Creates the combined figure with proper original sizing for both rows.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Create overall figure with proper total size\n",
    "    fig = plt.figure(figsize=(7.0, 4.2))\n",
    "    \n",
    "    # Create main GridSpec ONCE with 50/50 split and small hspace\n",
    "    gs = GridSpec(2, 1, figure=fig, height_ratios=[4.8, 2.2], hspace=0.01)\n",
    "    \n",
    "    # Top row: 1x4 precipitation maps\n",
    "    top_axes = make_precip_row(\n",
    "        fig=fig,\n",
    "        gridspec_position=gs[0],\n",
    "        precip_by_Ts=prec_dic,\n",
    "        Ts_order=[\"280K\", \"290K\", \"300K\", \"310K\"], \n",
    "        time_mode=\"index\",\n",
    "        time_index=23\n",
    "    )\n",
    "    \n",
    "    # Bottom row: centered 1x2 distributions\n",
    "    bottom_gs = gs[1].subgridspec(1, 4, width_ratios=[0.7, 6, 6, 0.7])\n",
    "    bottom_axes = make_distribution_row(\n",
    "        fig=fig,\n",
    "        position=[bottom_gs[1], bottom_gs[2]]\n",
    "    )\n",
    "\n",
    "    # Add panel labels outside top left of each panel\n",
    "    labels = ['a', 'b', 'c', 'd', 'e', 'f']\n",
    "    \n",
    "    # Label top row panels (a, b, c, d)\n",
    "    # for i, ax in enumerate(top_axes):\n",
    "    #     ax.text(-0.1, 1.05, labels[i], transform=ax.transAxes, \n",
    "    #             fontsize=12, ha='right', va='bottom', color='gray')\n",
    "    \n",
    "    # # Label bottom row panels (e, f)  \n",
    "    # for i, ax in enumerate(bottom_axes):\n",
    "    #     ax.text(0.1, 1.05, labels[i + 4], transform=ax.transAxes,\n",
    "    #             fontsize=12, ha='right', va='bottom', color='gray')\n",
    "    #     fig.text(0.5, -0.01, 'mm/day', ha='center', va='bottom', fontsize=6)\n",
    "    \n",
    "    if save_path:\n",
    "        plt.savefig(save_path, bbox_inches='tight', dpi=300)\n",
    "        print(f\"Figure saved to: {save_path}\")\n",
    "    \n",
    "    return fig\n",
    "\n",
    "# How to run it:\n",
    "# Option 1: Just create and show\n",
    "fig = make_combined_figure(save_path=sdir)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
